* are not used elsewhere. These APIs may ultimately get dropped entirely and
* replaced by something else.
*/
+/* exported ConcurrentBatch, ConsecutiveBatch */
const { GObject } = imports.gi;
-const Signals = imports.signals;
+const Signals = imports.misc.signals;
-var Task = class {
+var Task = class extends Signals.EventEmitter {
constructor(scope, handler) {
+ super();
+
if (scope)
this.scope = scope;
else
return null;
}
};
-Signals.addSignalMethods(Task.prototype);
var Hold = class extends Task {
constructor() {
return this._acquisitions > 0;
}
};
-Signals.addSignalMethods(Hold.prototype);
var Batch = class extends Task {
constructor(scope, tasks) {
this.tasks = this.tasks.splice(0, this._currentTaskIndex + 1);
}
};
-Signals.addSignalMethods(Batch.prototype);
var ConcurrentBatch = class extends Batch {
process() {
this.nextTask();
}
};
-Signals.addSignalMethods(ConcurrentBatch.prototype);
var ConsecutiveBatch = class extends Batch {
process() {
}
}
};
-Signals.addSignalMethods(ConsecutiveBatch.prototype);
// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
/* exported CredentialManager */
-var CredentialManager = class CredentialManager {
+const Signals = imports.misc.signals;
+
+var CredentialManager = class CredentialManager extends Signals.EventEmitter {
constructor(service) {
+ super();
+
this._token = null;
this._service = service;
this._authenticatedSignalId = null;
/* exported getOVirtCredentialsManager */
const Gio = imports.gi.Gio;
-const Signals = imports.signals;
const Credential = imports.gdm.credentialManager;
var SERVICE_NAME = 'gdm-ovirtcred';
});
}
};
-Signals.addSignalMethods(OVirtCredentialsManager.prototype);
function getOVirtCredentialsManager() {
if (!_oVirtCredentialsManager)
// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported Manager */
const Gio = imports.gi.Gio;
-const Signals = imports.signals;
+const Signals = imports.misc.signals;
const { loadInterfaceXML } = imports.misc.fileUtils;
const RealmIface = loadInterfaceXML("org.freedesktop.realmd.Realm");
const Realm = Gio.DBusProxy.makeProxyWrapper(RealmIface);
-var Manager = class {
+var Manager = class extends Signals.EventEmitter {
constructor() {
+ super();
+
this._aggregateProvider = Provider(Gio.DBus.system,
'org.freedesktop.realmd',
'/org/freedesktop/realmd',
this._updateLoginFormat();
}
};
-Signals.addSignalMethods(Manager.prototype);
// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
/* exported BANNER_MESSAGE_KEY, BANNER_MESSAGE_TEXT_KEY, LOGO_KEY,
- DISABLE_USER_LIST_KEY, fadeInActor, fadeOutActor, cloneAndFadeOutActor */
+ DISABLE_USER_LIST_KEY, fadeInActor, fadeOutActor, cloneAndFadeOutActor,
+ ShellUserVerifier */
const { Clutter, Gdm, Gio, GLib } = imports.gi;
-const Signals = imports.signals;
+const Signals = imports.misc.signals;
const Batch = imports.gdm.batch;
const OVirt = imports.gdm.oVirt;
return hold;
}
-var ShellUserVerifier = class {
+var ShellUserVerifier = class extends Signals.EventEmitter {
constructor(client, params) {
+ super();
params = Params.parse(params, { reauthenticationOnly: false });
this._reauthOnly = params.reauthenticationOnly;
this._verificationFailed(serviceName, true);
}
};
-Signals.addSignalMethods(ShellUserVerifier.prototype);
/* exported getVmwareCredentialsManager */
const Gio = imports.gi.Gio;
-const Signals = imports.signals;
const Credential = imports.gdm.credentialManager;
const dbusPath = '/org/vmware/viewagent/Credentials';
});
}
};
-Signals.addSignalMethods(VmwareCredentialsManager.prototype);
function getVmwareCredentialsManager() {
if (!_vmwareCredentialsManager)
<file>misc/permissionStore.js</file>
<file>misc/signalTracker.js</file>
<file>misc/smartcardManager.js</file>
+ <file>misc/signals.js</file>
<file>misc/systemActions.js</file>
<file>misc/util.js</file>
<file>misc/weather.js</file>
// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported HistoryManager */
-const Signals = imports.signals;
+const Signals = imports.misc.signals;
const Clutter = imports.gi.Clutter;
const Params = imports.misc.params;
var DEFAULT_LIMIT = 512;
-var HistoryManager = class {
+var HistoryManager = class extends Signals.EventEmitter {
constructor(params) {
+ super();
+
params = Params.parse(params, {
gsettingsKey: null,
limit: DEFAULT_LIMIT,
global.settings.set_strv(this._key, this._history);
}
};
-Signals.addSignalMethods(HistoryManager.prototype);
/* exported getIBusManager */
const { Gio, GLib, IBus, Meta, Shell } = imports.gi;
-const Signals = imports.signals;
+const Signals = imports.misc.signals;
const IBusCandidatePopup = imports.ui.ibusCandidatePopup;
return _ibusManager;
}
-var IBusManager = class {
+var IBusManager = class extends Signals.EventEmitter {
constructor() {
+ super();
+
IBus.init();
// This is the longest we'll keep the keyboard frozen until an input
});
}
};
-Signals.addSignalMethods(IBusManager.prototype);
/* exported canLock, getLoginManager, registerSessionWithGDM */
const { GLib, Gio } = imports.gi;
-const Signals = imports.signals;
+const Signals = imports.misc.signals;
const { loadInterfaceXML } = imports.misc.fileUtils;
return _loginManager;
}
-var LoginManagerSystemd = class {
+var LoginManagerSystemd = class extends Signals.EventEmitter {
constructor() {
+ super();
+
this._proxy = new SystemdLoginManager(Gio.DBus.system,
'org.freedesktop.login1',
'/org/freedesktop/login1');
this.emit('prepare-for-sleep', aboutToSuspend);
}
};
-Signals.addSignalMethods(LoginManagerSystemd.prototype);
-var LoginManagerDummy = class {
+var LoginManagerDummy = class extends Signals.EventEmitter {
getCurrentSessionProxy(_callback) {
// we could return a DummySession object that fakes whatever callers
// expect (at the time of writing: connect() and connectSignal()
return null;
}
};
-Signals.addSignalMethods(LoginManagerDummy.prototype);
// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported ObjectManager */
const { Gio, GLib } = imports.gi;
const Params = imports.misc.params;
-const Signals = imports.signals;
+const Signals = imports.misc.signals;
// Specified in the D-Bus specification here:
// http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager
const ObjectManagerInfo = Gio.DBusInterfaceInfo.new_for_xml(ObjectManagerIface);
-var ObjectManager = class {
+var ObjectManager = class extends Signals.EventEmitter {
constructor(params) {
+ super();
+
params = Params.parse(params, {
connection: null,
name: null,
return proxies;
}
};
-Signals.addSignalMethods(ObjectManager.prototype);
-/* exported TransientSignalHolder, addObjectSignalMethods */
+/* exported TransientSignalHolder, connectObject, disconnectObject */
const { GObject } = imports.gi;
const destroyableTypes = [];
SignalManager.getDefault().getSignalTracker(thisObj).untrack(obj);
}
-/**
- * Add connectObject()/disconnectObject() methods
- * to prototype. The prototype must have the connect()
- * and disconnect() signal methods.
- *
- * @param {prototype} proto - a prototype
- */
-function addObjectSignalMethods(proto) {
- proto['connectObject'] = function (...args) {
- connectObject(this, ...args);
- };
- proto['connect_object'] = proto['connectObject'];
-
- proto['disconnectObject'] = function (obj) {
- disconnectObject(this, obj);
- };
- proto['disconnect_object'] = proto['disconnectObject'];
-}
-
/**
* Register a GObject type as having a 'destroy' signal
* that should disconnect all handlers
--- /dev/null
+const Signals = imports.signals;
+const SignalTracker = imports.misc.signalTracker;
+
+var EventEmitter = class EventEmitter {
+ connectObject(...args) {
+ return SignalTracker.connectObject(this, ...args);
+ }
+
+ disconnectObject(...args) {
+ return SignalTracker.disconnectObject(this, ...args);
+ }
+
+ connect_object(...args) {
+ return this.connectObject(...args);
+ }
+
+ disconnect_object(...args) {
+ return this.disconnectObject(...args);
+ }
+};
+
+Signals.addSignalMethods(EventEmitter.prototype);
/* exported getSmartcardManager */
const Gio = imports.gi.Gio;
-const Signals = imports.signals;
+const Signals = imports.misc.signals;
const ObjectManager = imports.misc.objectManager;
return _smartcardManager;
}
-var SmartcardManager = class {
+var SmartcardManager = class extends Signals.EventEmitter {
constructor() {
+ super();
+
this._objectManager = new ObjectManager.ObjectManager({
connection: Gio.DBus.session,
name: 'org.gnome.SettingsDaemon.Smartcard',
return true;
}
};
-Signals.addSignalMethods(SmartcardManager.prototype);
// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported WeatherClient */
const { Geoclue, Gio, GLib, GWeather, Shell } = imports.gi;
-const Signals = imports.signals;
+const Signals = imports.misc.signals;
const PermissionStore = imports.misc.permissionStore;
// Minimum time between updates to show loading indication
var UPDATE_THRESHOLD = 10 * GLib.TIME_SPAN_MINUTE;
-var WeatherClient = class {
+var WeatherClient = class extends Signals.EventEmitter {
constructor() {
+ super();
+
this._loading = false;
this._locationValid = false;
this._lastUpdate = GLib.DateTime.new_from_unix_local(0);
this._updateAutoLocation();
}
};
-Signals.addSignalMethods(WeatherClient.prototype);
const Shell = imports.gi.Shell;
const ParentalControlsManager = imports.misc.parentalControlsManager;
-const Signals = imports.signals;
+const Signals = imports.misc.signals;
const Main = imports.ui.main;
'evince.desktop': 'org.gnome.Evince.desktop',
};
-class AppFavorites {
+class AppFavorites extends Signals.EventEmitter {
constructor() {
+ super();
+
// Filter the apps through the user’s parental controls.
this._parentalControlsManager = ParentalControlsManager.getDefault();
this._parentalControlsManager.connect('app-filter-changed', () => {
});
}
}
-Signals.addSignalMethods(AppFavorites.prototype);
var appFavoritesInstance = null;
function getAppFavorites() {
// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
-/* exported SystemBackground */
+/* exported SystemBackground, BackgroundManager */
// READ THIS FIRST
// Background handling is a maze of objects, both objects in this file, and
// MetaBackgroundImage MetaBackgroundImage
const { Clutter, GDesktopEnums, Gio, GLib, GObject, GnomeDesktop, Meta } = imports.gi;
-const Signals = imports.signals;
+const Signals = imports.misc.signals;
const LoginManager = imports.misc.loginManager;
const Main = imports.ui.main;
return file1.equal(file2);
}
-var BackgroundCache = class BackgroundCache {
+var BackgroundCache = class BackgroundCache extends Signals.EventEmitter {
constructor() {
+ super();
+
this._fileMonitors = {};
this._backgroundSources = {};
this._animations = {};
}
}
};
-Signals.addSignalMethods(BackgroundCache.prototype);
function getBackgroundCache() {
if (!_backgroundCache)
}
});
-var BackgroundManager = class BackgroundManager {
+var BackgroundManager = class BackgroundManager extends Signals.EventEmitter {
constructor(params) {
+ super();
params = Params.parse(params, {
container: null,
layoutManager: Main.layoutManager,
return backgroundActor;
}
};
-Signals.addSignalMethods(BackgroundManager.prototype);
/* exported Component */
const { Clutter, Gio, GLib, GObject, NM, Pango, Shell, St } = imports.gi;
-const Signals = imports.signals;
+const Signals = imports.misc.signals;
const Dialog = imports.ui.dialog;
const Main = imports.ui.main;
}
});
-var VPNRequestHandler = class {
+var VPNRequestHandler = class extends Signals.EventEmitter {
constructor(agent, requestId, authHelper, serviceType, connection, hints, flags) {
+ super();
+
this._agent = agent;
this._requestId = requestId;
this._connection = connection;
}
}
};
-Signals.addSignalMethods(VPNRequestHandler.prototype);
var NetworkAgent = class {
constructor() {
/* exported addDragMonitor, removeDragMonitor, makeDraggable */
const { Clutter, GLib, Meta, Shell, St } = imports.gi;
-const Signals = imports.signals;
+const Signals = imports.misc.signals;
const Main = imports.ui.main;
const Params = imports.misc.params;
}
}
-var _Draggable = class _Draggable {
+var _Draggable = class _Draggable extends Signals.EventEmitter {
constructor(actor, params) {
+ super();
+
params = Params.parse(params, {
manualMode: false,
timeoutThreshold: 0,
currentDraggable = null;
}
};
-Signals.addSignalMethods(_Draggable.prototype);
/**
* makeDraggable:
const { Clutter, Gio, GLib, GObject, Meta, Polkit, Shell, St } = imports.gi;
const Gettext = imports.gettext;
-const Signals = imports.signals;
const System = imports.system;
const SignalTracker = imports.misc.signalTracker;
SignalTracker.disconnectObject(this, ...args);
};
- const _addSignalMethods = Signals.addSignalMethods;
- Signals.addSignalMethods = function (prototype) {
- _addSignalMethods(prototype);
- SignalTracker.addObjectSignalMethods(prototype);
- };
-
SignalTracker.registerDestroyableType(Clutter.Actor);
// Miscellaneous monkeypatching
// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
-/* exported init connect disconnect */
+/* exported init connect disconnect ExtensionManager */
const { GLib, Gio, GObject, Shell, St } = imports.gi;
-const Signals = imports.signals;
+const Signals = imports.misc.signals;
const ExtensionDownloader = imports.ui.extensionDownloader;
const ExtensionUtils = imports.misc.extensionUtils;
const UPDATE_CHECK_TIMEOUT = 24 * 60 * 60; // 1 day in seconds
-var ExtensionManager = class {
+var ExtensionManager = class extends Signals.EventEmitter {
constructor() {
+ super();
+
this._initialized = false;
this._updateNotified = false;
this._enableAllExtensions();
}
};
-Signals.addSignalMethods(ExtensionManager.prototype);
const ExtensionUpdateSource = GObject.registerClass(
class ExtensionUpdateSource extends MessageTray.Source {
* Contributor:
* Magdalen Berns <m.berns@sms.ed.ac.uk>
*/
+/* exported FocusCaretTracker */
const Atspi = imports.gi.Atspi;
-const Signals = imports.signals;
+const Signals = imports.misc.signals;
const CARETMOVED = 'object:text-caret-moved';
const STATECHANGED = 'object:state-changed';
-var FocusCaretTracker = class FocusCaretTracker {
+var FocusCaretTracker = class FocusCaretTracker extends Signals.EventEmitter {
constructor() {
+ super();
+
this._atspiListener = Atspi.EventListener.new(this._onChanged.bind(this));
this._atspiInited = false;
this._caretListenerRegistered = false;
}
};
-Signals.addSignalMethods(FocusCaretTracker.prototype);
/* exported KeyboardManager */
const { Clutter, Gio, GLib, GObject, Graphene, Meta, Shell, St } = imports.gi;
-const Signals = imports.signals;
+const Signals = imports.misc.signals;
const EdgeDragAction = imports.ui.edgeDragAction;
const InputSourceManager = imports.ui.status.keyboard;
}
};
-var FocusTracker = class {
+var FocusTracker = class extends Signals.EventEmitter {
constructor() {
+ super();
+
this._rect = null;
global.display.connectObject(
return rect;
}
};
-Signals.addSignalMethods(FocusTracker.prototype);
var EmojiPager = GObject.registerClass({
Properties: {
}
});
-var KeyboardController = class {
+var KeyboardController = class extends Signals.EventEmitter {
constructor() {
+ super();
+
let seat = Clutter.get_default_backend().get_default_seat();
this._virtualDevice = seat.create_virtual_device(Clutter.InputDeviceType.KEYBOARD_DEVICE);
keyval, Clutter.KeyState.RELEASED);
}
};
-Signals.addSignalMethods(KeyboardController.prototype);
/* exported MonitorConstraint, LayoutManager */
const { Clutter, Gio, GLib, GObject, Meta, Shell, St } = imports.gi;
-const Signals = imports.signals;
+const Signals = imports.misc.signals;
const Background = imports.ui.background;
const BackgroundMenu = imports.ui.backgroundMenu;
}
});
-var PressureBarrier = class PressureBarrier {
+var PressureBarrier = class PressureBarrier extends Signals.EventEmitter {
constructor(threshold, timeout, actionMode) {
+ super();
+
this._threshold = threshold;
this._timeout = timeout;
this._actionMode = actionMode;
this._trigger();
}
};
-Signals.addSignalMethods(PressureBarrier.prototype);
var ScreenTransition = GObject.registerClass(
class ScreenTransition extends Clutter.Actor {
const {
Clutter, Cogl, Gio, GLib, GObject, Graphene, Meta, Pango, Shell, St,
} = imports.gi;
-const Signals = imports.signals;
+const Signals = imports.misc.signals;
const System = imports.system;
const History = imports.misc.history;
return keywords.concat(windowProperties).concat(headerProperties);
}
-var AutoComplete = class AutoComplete {
+var AutoComplete = class AutoComplete extends Signals.EventEmitter {
constructor(entry) {
+ super();
+
this._entry = entry;
this._entry.connect('key-press-event', this._entryKeyPressEvent.bind(this));
this._lastTabTime = global.get_current_time();
this._entry.clutter_text.insert_text(additionalCompletionText, cursorPos);
}
};
-Signals.addSignalMethods(AutoComplete.prototype);
var Notebook = GObject.registerClass({
// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported Magnifier */
const {
Atspi, Clutter, GDesktopEnums, Gio, GLib, GObject, Meta, Shell, St,
} = imports.gi;
-const Signals = imports.signals;
+const Signals = imports.misc.signals;
const Background = imports.ui.background;
const FocusCaretTracker = imports.ui.focusCaretTracker;
}
});
-var Magnifier = class Magnifier {
+var Magnifier = class Magnifier extends Signals.EventEmitter {
constructor() {
+ super();
+
// Magnifier is a manager of ZoomRegions.
this._zoomRegions = [];
}
}
};
-Signals.addSignalMethods(Magnifier.prototype);
var ZoomRegion = class ZoomRegion {
constructor(magnifier, mouseSourceActor) {
/* exported MediaSection */
const { Gio, GObject, Shell, St } = imports.gi;
-const Signals = imports.signals;
+const Signals = imports.misc.signals;
const Main = imports.ui.main;
const MessageList = imports.ui.messageList;
}
});
-var MprisPlayer = class MprisPlayer {
+var MprisPlayer = class MprisPlayer extends Signals.EventEmitter {
constructor(busName) {
+ super();
+
this._mprisProxy = new MprisProxy(Gio.DBus.session, busName,
- '/org/mpris/MediaPlayer2',
- this._onMprisProxyReady.bind(this));
+ '/org/mpris/MediaPlayer2',
+ this._onMprisProxyReady.bind(this));
this._playerProxy = new MprisPlayerProxy(Gio.DBus.session, busName,
- '/org/mpris/MediaPlayer2',
- this._onPlayerProxyReady.bind(this));
+ '/org/mpris/MediaPlayer2',
+ this._onPlayerProxyReady.bind(this));
this._visible = false;
this._trackArtists = [];
}
}
};
-Signals.addSignalMethods(MprisPlayer.prototype);
var MediaSection = GObject.registerClass(
class MediaSection extends MessageList.MessageListSection {
/* exported Overview, ANIMATION_TIME */
const { Clutter, Gio, GLib, GObject, Meta, Shell, St } = imports.gi;
-const Signals = imports.signals;
+const Signals = imports.misc.signals;
// Time for initial animation going into Overview mode;
// this is defined here to make it available in imports.
}
});
-var Overview = class {
+var Overview = class extends Signals.EventEmitter {
constructor() {
+ super();
+
this._initCalled = false;
this._visible = false;
return this._overview.searchEntry;
}
};
-Signals.addSignalMethods(Overview.prototype);
Atk, Clutter, GDesktopEnums, Gio,
GLib, GObject, Gtk, Meta, Pango, Rsvg, St,
} = imports.gi;
-const Signals = imports.signals;
+const Signals = imports.misc.signals;
const Main = imports.ui.main;
const PopupMenu = imports.ui.popupMenu;
const PadOsdIface = loadInterfaceXML('org.gnome.Shell.Wacom.PadOsd');
-var PadOsdService = class {
+var PadOsdService = class extends Signals.EventEmitter {
constructor() {
+ super();
+
this._dbusImpl = Gio.DBusExportedObject.wrapJSObject(PadOsdIface, this);
this._dbusImpl.export(Gio.DBus.session, '/org/gnome/Shell/Wacom');
Gio.DBus.session.own_name('org.gnome.Shell.Wacom.PadOsd', Gio.BusNameOwnerFlags.REPLACE, null, null);
invocation.return_value(null);
}
};
-Signals.addSignalMethods(PadOsdService.prototype);
PopupMenuSection, PopupSubMenuMenuItem, PopupMenuManager */
const { Atk, Clutter, Gio, GObject, Graphene, Shell, St } = imports.gi;
-const Signals = imports.signals;
+const Signals = imports.misc.signals;
const BoxPointer = imports.ui.boxpointer;
const Main = imports.ui.main;
}
});
-var PopupMenuBase = class {
+var PopupMenuBase = class extends Signals.EventEmitter {
constructor(sourceActor, styleClass) {
+ super();
+
if (this.constructor === PopupMenuBase)
throw new TypeError(`Cannot instantiate abstract class ${this.constructor.name}`);
Main.sessionMode.disconnectObject(this);
}
};
-Signals.addSignalMethods(PopupMenuBase.prototype);
var PopupMenu = class extends PopupMenuBase {
constructor(sourceActor, arrowAlignment, arrowSide) {
}
};
-var PopupDummyMenu = class {
+var PopupDummyMenu = class extends Signals.EventEmitter {
constructor(sourceActor) {
+ super();
+
this.sourceActor = sourceActor;
this.actor = sourceActor;
this.actor._delegate = this;
this.emit('destroy');
}
};
-Signals.addSignalMethods(PopupDummyMenu.prototype);
var PopupSubMenu = class extends PopupMenuBase {
constructor(sourceActor, sourceArrow) {
// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported ScreenShield */
const {
AccountsService, Clutter, Gio,
GLib, Graphene, Meta, Shell, St,
} = imports.gi;
-const Signals = imports.signals;
+const Signals = imports.misc.signals;
const GnomeSession = imports.misc.gnomeSession;
const OVirt = imports.gdm.oVirt;
* This will ensure that the screen blanks at the right time when it fades out.
* https://bugzilla.gnome.org/show_bug.cgi?id=668703 explains the dependency.
*/
-var ScreenShield = class {
+var ScreenShield = class extends Signals.EventEmitter {
constructor() {
+ super();
+
this.actor = Main.layoutManager.screenShieldGroup;
this._lockScreenState = MessageTray.State.HIDDEN;
});
}
};
-Signals.addSignalMethods(ScreenShield.prototype);
/* exported SessionMode, listModes */
const GLib = imports.gi.GLib;
-const Signals = imports.signals;
+const Signals = imports.misc.signals;
const FileUtils = imports.misc.fileUtils;
const Params = imports.misc.params;
loop.run();
}
-var SessionMode = class {
+var SessionMode = class extends Signals.EventEmitter {
constructor() {
+ super();
+
_loadModes();
let isPrimary = _modes[global.session_mode] &&
_modes[global.session_mode].isPrimary;
this.emit('updated');
}
};
-Signals.addSignalMethods(SessionMode.prototype);
const { Clutter, Gio, GLib, GObject, IBus, Meta, Shell, St } = imports.gi;
const Gettext = imports.gettext;
-const Signals = imports.signals;
+const Signals = imports.misc.signals;
const IBusManager = imports.misc.ibusManager;
const KeyboardManager = imports.misc.keyboardManager;
}
});
-var InputSource = class {
+var InputSource = class extends Signals.EventEmitter {
constructor(type, id, displayName, shortName, index) {
+ super();
+
this.type = type;
this.id = id;
this.displayName = displayName;
return engineDesc.layout;
}
};
-Signals.addSignalMethods(InputSource.prototype);
var InputSourcePopup = GObject.registerClass(
class InputSourcePopup extends SwitcherPopup.SwitcherPopup {
}
});
-var InputSourceSettings = class {
+var InputSourceSettings = class extends Signals.EventEmitter {
constructor() {
+ super();
+
if (this.constructor === InputSourceSettings)
throw new TypeError(`Cannot instantiate abstract class ${this.constructor.name}`);
}
return false;
}
};
-Signals.addSignalMethods(InputSourceSettings.prototype);
var InputSourceSystemSettings = class extends InputSourceSettings {
constructor() {
}
};
-var InputSourceManager = class {
+var InputSourceManager = class extends Signals.EventEmitter {
constructor() {
+ super();
+
// All valid input sources currently in the gsettings
// KEY_INPUT_SOURCES list indexed by their index there
this._inputSources = {};
return this._keyboardManager;
}
};
-Signals.addSignalMethods(InputSourceManager.prototype);
let _inputSourceManager = null;
// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
/* exported NMApplet */
const { Clutter, Gio, GLib, GObject, Meta, NM, Polkit, St } = imports.gi;
-const Signals = imports.signals;
+const Signals = imports.misc.signals;
const Animation = imports.ui.animation;
const Main = imports.ui.main;
}
}
-var NMConnectionItem = class {
+var NMConnectionItem = class extends Signals.EventEmitter {
constructor(section, connection) {
+ super();
+
this._section = section;
this._connection = connection;
this._activeConnection = null;
this._sync();
}
};
-Signals.addSignalMethods(NMConnectionItem.prototype);
-var NMConnectionSection = class NMConnectionSection {
+var NMConnectionSection = class NMConnectionSection extends Signals.EventEmitter {
constructor(client) {
+ super();
+
if (this.constructor === NMConnectionSection)
throw new TypeError(`Cannot instantiate abstract type ${this.constructor.name}`);
this._sync();
}
};
-Signals.addSignalMethods(NMConnectionSection.prototype);
var NMConnectionDevice = class NMConnectionDevice extends NMConnectionSection {
constructor(client, device) {
}
});
-var NMDeviceWireless = class {
+var NMDeviceWireless = class extends Signals.EventEmitter {
constructor(client, device) {
+ super();
+
this._client = client;
this._device = device;
return 'network-wireless-no-route-symbolic';
}
};
-Signals.addSignalMethods(NMDeviceWireless.prototype);
var NMWireguardItem = class extends NMConnectionItem {
_buildUI() {
return '';
}
};
-Signals.addSignalMethods(NMVpnSection.prototype);
var DeviceCategory = class extends PopupMenu.PopupMenuSection {
constructor(category) {
/* exported Indicator */
const { Gio, GObject } = imports.gi;
-const Signals = imports.signals;
+const Signals = imports.misc.signals;
const Main = imports.ui.main;
const PanelMenu = imports.ui.panelMenu;
const RfkillManagerInterface = loadInterfaceXML('org.gnome.SettingsDaemon.Rfkill');
const RfkillManagerProxy = Gio.DBusProxy.makeProxyWrapper(RfkillManagerInterface);
-var RfkillManager = class {
+var RfkillManager = class extends Signals.EventEmitter {
constructor() {
+ super();
+
this._proxy = new RfkillManagerProxy(Gio.DBus.session, BUS_NAME, OBJECT_PATH,
- (proxy, error) => {
- if (error) {
- log(error.message);
- return;
- }
- this._proxy.connect('g-properties-changed',
- this._changed.bind(this));
- this._changed();
- });
+ (proxy, error) => {
+ if (error) {
+ log(error.message);
+ return;
+ }
+ this._proxy.connect('g-properties-changed',
+ this._changed.bind(this));
+ this._changed();
+ });
}
get airplaneMode() {
this.emit('airplane-mode-changed');
}
};
-Signals.addSignalMethods(RfkillManager.prototype);
var _manager;
function getRfkillManager() {
// the following is a modified version of bolt/contrib/js/client.js
const { Gio, GLib, GObject, Polkit, Shell } = imports.gi;
-const Signals = imports.signals;
+const Signals = imports.misc.signals;
const Main = imports.ui.main;
const MessageTray = imports.ui.messageTray;
const BOLT_DBUS_NAME = 'org.freedesktop.bolt';
const BOLT_DBUS_PATH = '/org/freedesktop/bolt';
-var Client = class {
+var Client = class extends Signals.EventEmitter {
constructor() {
+ super();
+
this._proxy = null;
this.probing = false;
this._getProxy();
return this._proxy.AuthMode;
}
};
-Signals.addSignalMethods(Client.prototype);
/* helper class to automatically authorize new devices */
-var AuthRobot = class {
+var AuthRobot = class extends Signals.EventEmitter {
constructor(client) {
+ super();
+
this._client = client;
this._devicesToEnroll = [];
return GLib.SOURCE_REMOVE;
}
};
-Signals.addSignalMethods(AuthRobot.prototype);
/* eof client.js */
/* exported Indicator */
const { Clutter, Gio, GLib, GObject, Gvc, St } = imports.gi;
-const Signals = imports.signals;
+const Signals = imports.misc.signals;
const Main = imports.ui.main;
const PanelMenu = imports.ui.panelMenu;
return _mixerControl;
}
-var StreamSlider = class {
+var StreamSlider = class extends Signals.EventEmitter {
constructor(control) {
+ super();
+
this._control = control;
this.item = new PopupMenu.PopupBaseMenuItem({ activate: false });
return maxVolume / this._control.get_vol_max_norm();
}
};
-Signals.addSignalMethods(StreamSlider.prototype);
var OutputStreamSlider = class extends StreamSlider {
constructor(control) {
// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported XdndHandler */
const { Clutter } = imports.gi;
-const Signals = imports.signals;
+const Signals = imports.misc.signals;
const DND = imports.ui.dnd;
const Main = imports.ui.main;
-var XdndHandler = class {
+var XdndHandler = class extends Signals.EventEmitter {
constructor() {
+ super();
+
// Used to display a clone of the cursor window when the
// window group is hidden (like it happens in the overview)
this._cursorWindowClone = null;
}
}
};
-Signals.addSignalMethods(XdndHandler.prototype);
const { GObject } = imports.gi;
const JsUnit = imports.jsUnit;
-const Signals = imports.signals;
+const Signals = imports.misc.signals;
const Environment = imports.ui.environment;
const { TransientSignalHolder, registerDestroyableType } = imports.misc.signalTracker;
}, class Destroyable extends GObject.Object {});
registerDestroyableType(Destroyable);
-class PlainEmitter {}
-Signals.addSignalMethods(PlainEmitter.prototype);
-
const GObjectEmitter = GObject.registerClass({
Signals: { 'signal': {} },
}, class GObjectEmitter extends Destroyable {});
-const emitter1 = new PlainEmitter();
+const emitter1 = new Signals.EventEmitter();
const emitter2 = new GObjectEmitter();
const tracked1 = new Destroyable();
projects / gnome-shell.git / commitdiff